package com.atguigu.tingshu.album.service.impl;

import com.atguigu.tingshu.album.client.AlbumInfoFeignClient;
import com.atguigu.tingshu.album.config.VodConstantProperties;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.TrackInfoMapper;
import com.atguigu.tingshu.album.mapper.TrackStatMapper;
import com.atguigu.tingshu.album.service.TrackInfoService;
import com.atguigu.tingshu.album.service.VodService;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.result.Result;
import com.atguigu.tingshu.common.util.AuthContextHolder;
import com.atguigu.tingshu.common.util.UploadFileUtil;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.TrackInfo;
import com.atguigu.tingshu.model.album.TrackStat;
import com.atguigu.tingshu.model.user.UserInfo;
import com.atguigu.tingshu.query.album.TrackInfoQuery;
import com.atguigu.tingshu.user.client.UserInfoFeignClient;
import com.atguigu.tingshu.vo.album.*;
import com.atguigu.tingshu.vo.user.UserInfoVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.qcloud.vod.VodUploadClient;
import com.qcloud.vod.model.VodUploadRequest;
import com.qcloud.vod.model.VodUploadResponse;
import com.tencentcloudapi.common.AbstractModel;
import com.tencentcloudapi.common.Credential;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import com.tencentcloudapi.common.profile.ClientProfile;
import com.tencentcloudapi.common.profile.HttpProfile;
import com.tencentcloudapi.vod.v20180717.VodClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.web.multipart.MultipartFile;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class TrackInfoServiceImpl extends ServiceImpl<TrackInfoMapper, TrackInfo> implements TrackInfoService {

	@Autowired
	private TrackInfoMapper trackInfoMapper;
	@Autowired
	private VodConstantProperties vodConstantProperties;
	@Autowired
	private AlbumInfoMapper albumInfoMapper;
	@Autowired
	private VodService vodService;
	@Autowired
	private TrackStatMapper trackStatMapper;

	@Autowired
	private AlbumInfoFeignClient albumInfoFeignClient;

	@Autowired
	private UserInfoFeignClient userInfoFeignClient;



	/**
	 * 上传音轨文件
	 * 该方法用于处理音轨文件的上传，包括临时文件的上传和音轨信息的获取
	 *
	 * @param file 用户上传的音轨文件，作为multipart形式的数据
	 * @return 返回一个包含音轨文件ID和媒体URL的Map对象
	 */
	@Override
	public Map<String,Object> uploadTrack(MultipartFile file) {
	    // 上传临时文件并获取文件路径
	    String filePath = UploadFileUtil.uploadTempPath(vodConstantProperties.getTempPath(), file);

	    // 创建Vod上传客户端
	    VodUploadClient client = new VodUploadClient(vodConstantProperties.getSecretId(), vodConstantProperties.getSecretKey());

	    // 创建上传请求对象并设置媒体文件路径
	    VodUploadRequest request = new VodUploadRequest();
	    request.setMediaFilePath(filePath);

	    // 初始化返回结果Map
	    HashMap<String, Object> map = new HashMap<>();

	    try {
	        // 执行上传操作并获取响应
	        VodUploadResponse response = client.upload(vodConstantProperties.getRegion(), request);
	        // 将音轨文件ID和媒体URL存入结果Map
	        map.put("mediaFileId", response.getFileId());
	        map.put("mediaUrl", response.getMediaUrl());

	        // 记录日志信息
	        log.info("Upload FileId = {}", response.getFileId());
			// 返回结果Map
			return map;
	    } catch (Exception e) {
	        // 业务方进行异常处理
	        log.error("Upload Err", e);
	    }

	    // 返回结果Map
	    return null;
	}

	@Transactional(rollbackFor = Exception.class)
	@Override
	public void saveTrackInfo(Long userId,TrackInfoVo trackInfoVo) {
//		根据album_id获取到albumInfo对象
		AlbumInfo albumInfo = albumInfoMapper.selectById(trackInfoVo.getAlbumId());
//		生成一个新的TrackInfo对象
		TrackInfo trackInfo = new TrackInfo();
//		使用工具类去拷贝数据
		BeanUtils.copyProperties(trackInfoVo,trackInfo);
//		给trackInfo中的userId属性赋值
		trackInfo.setUserId(userId);
//		给trackInfo中的order_num属性赋值
		trackInfo.setOrderNum(albumInfo.getIncludeTrackCount()+1);
//		找出对应的media对象
		TrackMediaInfoVo trackMediaInfoVo = vodService.getMedia(trackInfo.getMediaFileId());
//		封装对应的信息
		if(!ObjectUtils.isEmpty(trackMediaInfoVo)){
//			如果不为null,就封装对应的数据
			trackInfo.setMediaDuration(trackMediaInfoVo.getDuration());
			trackInfo.setMediaSize(trackMediaInfoVo.getSize());
			trackInfo.setMediaUrl(trackMediaInfoVo.getMediaUrl());
			trackInfo.setMediaType(trackMediaInfoVo.getType());
		}
//		插入TrackInfo数据
		trackInfoMapper.insert(trackInfo);
//		修改albumInfo中的includeTrackCount属性
		albumInfo.setIncludeTrackCount(albumInfo.getIncludeTrackCount()+1);
		albumInfoMapper.updateById(albumInfo);
//		添加对应的trackstat数据
		saveTrackStat(trackInfo.getId(), SystemConstant.TRACK_STAT_PLAY);
		saveTrackStat(trackInfo.getId(), SystemConstant.TRACK_STAT_COLLECT);
		saveTrackStat(trackInfo.getId(), SystemConstant.TRACK_STAT_PRAISE);
		saveTrackStat(trackInfo.getId(), SystemConstant.TRACK_STAT_COMMENT);

	}
	public void saveTrackStat(Long trackId,String statType) {
//		创建一个新的对象
		TrackStat trackStat = new TrackStat();
//		为新对象的属性赋值
		trackStat.setTrackId(trackId);
		trackStat.setStatType(statType);
		trackStat.setStatNum(new Random().nextInt(10000));
//		插入相关信息
		trackStatMapper.insert(trackStat);
	}

	@Override
	public IPage<TrackListVo> findUserTrackPage(Page<TrackListVo> page, TrackInfoQuery trackInfoQuery) {
		return trackInfoMapper.findUserTrackPage(page,trackInfoQuery);
	}

	@Transactional(rollbackFor = Exception.class)
	@Override
	public void removeTrackInfo(Long trackId) {
//		获取Id获取指定的trackInfo数据
		TrackInfo trackInfo = trackInfoMapper.selectById(trackId);
//		根据id删除trackInfo对象
		trackInfoMapper.deleteById(trackId);
//		获取声音所属的albumInfo对象
		AlbumInfo albumInfo = albumInfoMapper.selectById(trackInfo.getAlbumId());
//		修改她的声音总数
		albumInfo.setIncludeTrackCount(albumInfo.getIncludeTrackCount()-1);
//		更新albumInfo
		albumInfoMapper.updateById(albumInfo);
//		更新同一专辑的剩下的的orderNum值
		trackInfoMapper.updateOrderNum(trackInfo.getAlbumId(),trackInfo.getOrderNum());
//		删除所有的trackStat数据
		trackStatMapper.delete(new LambdaQueryWrapper<TrackStat>().eq(TrackStat::getTrackId,trackId));
//		删除指定的音频文件
		vodService.deleteMedia(trackInfo.getMediaFileId());
	}

	@Override
	public TrackInfo getTrackInfo(Long trackId) {
		return this.getById(trackId);
	}

	@Override
	public void updateTrackInfo(Long trackId,TrackInfoVo trackInfoVo) {
//		根据trackId获取一个新的数据
		TrackInfo trackInfo = this.getById(trackId);
//		获取原来的trackInfo数据
		String mediaFileId = trackInfo.getMediaFileId();
//		拷贝数据
		BeanUtils.copyProperties(trackInfoVo,trackInfo);
//		判断音频有没有被修改
		if (!mediaFileId.equals(trackInfoVo.getMediaFileId())){
//			如果不相等表示被修改了,就根据新的mediaFileId获取新的音频数据
			TrackMediaInfoVo media = vodService.getMedia(trackInfoVo.getMediaFileId());
//			获取后跟新新数据
			trackInfo.setMediaSize(media.getSize());
			trackInfo.setMediaUrl(media.getMediaUrl());
			trackInfo.setMediaDuration(media.getDuration());
			trackInfo.setMediaType(media.getType());
//			删除老音频文件
			vodService.deleteMedia(mediaFileId);
		}
//		更新数据
		this.updateById(trackInfo);
	}

	@Override
	public IPage<AlbumTrackListVo> findAlbumTrackPage(Page<AlbumTrackListVo> page, Long albumId) {
//		调用mapper层的方法去设计查询sql
		IPage<AlbumTrackListVo> trackListVoPage = trackInfoMapper.findAlbumTrackPage(page,albumId);
		if(null!= trackListVoPage){
//			先判断专辑类型  远程调用获取对应专辑
			Result<AlbumInfo> albumInfdo = albumInfoFeignClient.getAlbumInfo(albumId);
//			判断结果是否为空
			Assert.notNull(albumInfdo, "远程获取albumInfo数据失败");
//			获取调用结果中的有用信息
			AlbumInfo albumInfo = albumInfdo.getData();
//			判断结果是否为空
			Assert.notNull(albumInfo, "远程获取albumInfo数据失败");
			//				就需要从线程中获取用户id
			Long userId = AuthContextHolder.getUserId();
//				如果用户id不为空
			if(null!=userId){
//					远程调用获取用户信息
				Result<UserInfoVo> userInfoVo = userInfoFeignClient.getUserInfoVo(userId);
//					判断远程调用结果是否为空
				Assert.notNull(userInfoVo, "远程获取用户信息失败");
//					从中提取出数据
				UserInfoVo userInfo = userInfoVo.getData();
//					判断数据是否为空
				Assert.notNull(userInfo, "远程获取用户信息失败");
//				判断专辑类型
				if (!SystemConstant.ALBUM_PAY_TYPE_FREE.equals(albumInfo.getPayType())){
//					如果不是免费的就在判断是不是vip免费的
					if (SystemConstant.ALBUM_PAY_TYPE_VIPFREE.equals(albumInfo.getPayType())){
						//	判断用户是否是vip或者是vip但是已经过期了
						if(userInfo.getIsVip()==0?true:false || userInfo.getIsVip()==1 && userInfo.getVipExpireTime().before(new Date())){
////							先判断用户是否购买声音列表
//							trackListVoPage.getRecords().stream().filter(trackListVo->trackListVo.getOrderNum()>albumInfo.getTracksForFree()).forEach(
//									trackListVo->trackListVo.setIsShowPaidMark(true)
//							);
//							如果是付费观看的话,就需要远程调用查询付费表,并返回对应的数据
//						先获取要查询的所有需要判断的trackInfo的id
							List<Long> trackInfoList = trackListVoPage.getRecords().stream().filter(trackListVo -> trackListVo.getOrderNum() > albumInfo.getTracksForFree()).map(trackListVo -> trackListVo.getTrackId()).collect(Collectors.toList());
							if(ObjectUtils.isEmpty(trackInfoList)){
								return trackListVoPage;
							}
//						远程调用获取所有的购买数据
							Result<Map<Long, Integer>> isPaidTrack = userInfoFeignClient.userIsPaidTrack(albumId, trackInfoList);
//						判断远程调用结果是否为空
							Assert.notNull(isPaidTrack, "远程获取用户是否购买专辑失败");
//						获取对应的数据
							Map<Long, Integer> map = isPaidTrack.getData();
//						判断数据是否为空
							Assert.notNull(map, "远程获取用户是否购买专辑失败");
//						遍历
							trackListVoPage.getRecords().stream().filter(trackListVo->trackListVo.getOrderNum()>albumInfo.getTracksForFree()).forEach(
									trackListVo->{
										//	判断是否已经购买
										if(map.get(trackListVo.getTrackId())==1){
											trackListVo.setIsShowPaidMark(false);
										}else {
											trackListVo.setIsShowPaidMark(true);
										}
									}
							);
						}
					}else if (SystemConstant.ALBUM_PAY_TYPE_REQUIRE.equals(albumInfo.getPayType())){
//						如果是付费观看的话,就需要远程调用查询付费表,并返回对应的数据
//						先获取要查询的所有需要判断的trackInfo的id
						List<Long> trackInfoList = trackListVoPage.getRecords().stream().filter(trackListVo -> trackListVo.getOrderNum() > albumInfo.getTracksForFree()).map(trackListVo -> trackListVo.getTrackId()).collect(Collectors.toList());
						if(ObjectUtils.isEmpty(trackInfoList)){
							return trackListVoPage;
						}
//						远程调用获取所有的购买数据
						Result<Map<Long, Integer>> isPaidTrack = userInfoFeignClient.userIsPaidTrack(albumId, trackInfoList);
//						判断远程调用结果是否为空
						Assert.notNull(isPaidTrack, "远程获取用户是否购买专辑失败");
//						获取对应的数据
						Map<Long, Integer> map = isPaidTrack.getData();
//						判断数据是否为空
						Assert.notNull(map, "远程获取用户是否购买专辑失败");
//						遍历
						trackListVoPage.getRecords().stream().filter(trackListVo->trackListVo.getOrderNum()>albumInfo.getTracksForFree()).forEach(
								trackListVo->{
									//	判断是否已经购买
									if(map.get(trackListVo.getTrackId())==1){
										trackListVo.setIsShowPaidMark(false);
									}else {
										trackListVo.setIsShowPaidMark(true);
									}
								}
						);
					}
				}
			}else {
				//			判断专辑类型如果不是免费的专辑,就将显示付费标识设置为true
				if(!SystemConstant.ALBUM_PAY_TYPE_FREE.equals(albumInfo.getPayType())){
					trackListVoPage.getRecords().stream().filter(trackListVo->trackListVo.getOrderNum()>albumInfo.getTracksForFree()).forEach(
							trackListVo->trackListVo.setIsShowPaidMark(true)
					);
				}
			}
		}
		return trackListVoPage;
//		/*
//        1.  获取到当前专辑对应的声音列表;  50条;  专辑的类型：免费  【vip免费 付费 除了试听集数外，都应该付费】
//        2.  判断当前用户是否购买过声音或专辑！
//         */
//		IPage<AlbumTrackListVo> pageInfo = trackInfoMapper.findAlbumTrackPage(page, albumId);
//		//  根据专辑Id获取专辑对象
//		AlbumInfo albumInfo = albumInfoMapper.selectById(albumId);
////		从线程中获取用户id
//		Long userId = AuthContextHolder.getUserId();
//		//  判断用户是否登录!
//		if (null == userId) {
//			//  未登录！ 判断专辑类型;
//			String payType = albumInfo.getPayType();
//			if (!SystemConstant.ALBUM_PAY_TYPE_FREE.equals(payType)) {
//				//  vip免费 或 付费 除了试听集数外，都应该付费！
//				//  获取免费的试听集数
//				Integer tracksForFree = albumInfo.getTracksForFree();
//				//                for (AlbumTrackListVo albumTrackListVo : pageInfo.getRecords()) {
//				//                    if (albumTrackListVo.getOrderNum() > tracksForFree) {
//				//                        //  设置为付费
//				//                        albumTrackListVo.setIsShowPaidMark(true);
//				//                    }
//				//                }
//				pageInfo.getRecords().stream().filter(albumTrackListVo -> albumTrackListVo.getOrderNum() > tracksForFree).forEach(albumTrackListVo -> albumTrackListVo.setIsShowPaidMark(true));
//			}
//		} else {
//			//  专辑： 免费，付费，vip免费
//			//  用户登录    获取用户信息
//			Result<UserInfoVo> userInfoVoResult = userInfoFeignClient.getUserInfoVo(userId);
//			//  判断
//			Assert.notNull(userInfoVoResult, "用户信息不存在");
//			UserInfoVo userInfoVo = userInfoVoResult.getData();
//			//  判断
//			Assert.notNull(userInfoVo, "用户信息不存在");
//			//  声明一个付费标识;
//			boolean isPaid = false;
//			//  判断专辑类型为vip免费：
//			if (SystemConstant.ALBUM_PAY_TYPE_VIPFREE.equals(albumInfo.getPayType())) {
//				//  用户是否是vip - 不属于vip 或 是vip但已过期；需要收费
//				if (userInfoVo.getIsVip() == 0 || userInfoVo.getIsVip() == 1 && userInfoVo.getVipExpireTime().before(new Date())) {
//					isPaid = true;
//				}
//			} else if (SystemConstant.ALBUM_PAY_TYPE_REQUIRE.equals(albumInfo.getPayType())) {
//				//  需要付费;
//				isPaid = true;
//			}
//			//  统一处理付费情况
//			if (isPaid) {
//				//  需要付费！
//				//  1.  免费试听集数有多少集； 2.  用户是否购买过专辑(userId,albumId)user_paid_album，或购买过声音 user_paid_track！
//				Integer tracksForFree = albumInfo.getTracksForFree();
//				//  albumId = 1466  25条声音；5条免费； 付费20条； 判断用户是否够买过 20 条中的某一条声音！
//				List<AlbumTrackListVo> albumTrackListVoList = pageInfo.getRecords().stream().filter(albumTrackListVo -> albumTrackListVo.getOrderNum() > tracksForFree).collect(Collectors.toList());
//				List<Long> isNeedPaidTrackIdList = albumTrackListVoList.stream().map(AlbumTrackListVo::getTrackId).collect(Collectors.toList());
//				//  远程调用用户微服务的方法；
//				Result<Map<Long, Integer>> mapResult = userInfoFeignClient.userIsPaidTrack(albumId, isNeedPaidTrackIdList);
//				Assert.notNull(mapResult, "用户购买信息不存在");
//				//  trackId:1 trackId:0 1：表示购买过 0：未购买  isShowPaidMark=true或fasle;
//				Map<Long, Integer> map = mapResult.getData();
//				for (AlbumTrackListVo albumTrackListVo : albumTrackListVoList) {
//					//  map.get(albumTrackListVo.getTrackId()) == 1?albumTrackListVo.setIsShowPaidMark(false):albumTrackListVo.setIsShowPaidMark(true);
//					//  boolean flag = map.get(albumTrackListVo.getTrackId()) == 1?false:true; // 购买过；
//					boolean flag = map.get(albumTrackListVo.getTrackId()) == 1 ? false : true; // 购买过；
//					albumTrackListVo.setIsShowPaidMark(flag);
//				}
//			}
//		}
//		//  返回数据
//		return pageInfo;
	}

	@Transactional(rollbackFor = Exception.class)
	@Override
	public void updateTrackStat(TrackStatMqVo trackStatMqVo) {
//		让声音对应的播放量+1
		trackStatMapper.updateTrackStat(trackStatMqVo);
//		让专辑对应的播放量+1
		if (SystemConstant.TRACK_STAT_PLAY.equals(trackStatMqVo.getStatType())){
			Long albumId = trackStatMqVo.getAlbumId();
			String type = SystemConstant.ALBUM_STAT_PLAY;
			albumInfoMapper.updateAlbumStat(albumId,type);
		}
	}

	@Override
	public List<Map<String, Object>> findUserTrackPaidList(Long trackId,Long userId) {
//		创建一个list对象，用于封装返回的数据
		List<Map<String, Object>> list = new ArrayList<>();
//		先获取album专辑中，声音trackId后面有多少条数据
		TrackInfo trackInfo = trackInfoMapper.selectById(trackId);
//		再获取此条声音id后有多少条声音
		List<TrackInfo> trackInfoList = trackInfoMapper.selectList(new LambdaQueryWrapper<TrackInfo>().eq(TrackInfo::getAlbumId, trackInfo.getAlbumId()).gt(TrackInfo::getOrderNum, trackInfo.getOrderNum()));
//		远程调用查看用户已购买的声音
		Result<List<Long>> paidTrackListVo = userInfoFeignClient.findAllPaidTracks(trackInfo.getAlbumId());
//		判断远程调用的结果是否为空
		Assert.notNull(paidTrackListVo, "用户已购买信息不存在");
//		从中获取已购买的声音列表
		List<Long> padiTrackList = paidTrackListVo.getData();
//		这时候，不用判断声音列表是否为空，因为用户非常有可能没有购买任何声音数据
		if (padiTrackList!=null){
//			如果不为空的话，就便利trackInfoList得到用户没购买的专辑
			trackInfoList = trackInfoList.stream().filter(trackInfo1 -> !padiTrackList.contains(trackInfo1.getId())).collect(Collectors.toList());
		}
//		远程调用查询专辑信息
		Result<AlbumInfo> albumInfoVo = albumInfoFeignClient.getAlbumInfo(trackInfo.getAlbumId());
		Assert.notNull(albumInfoVo, "专辑信息不存在");
		AlbumInfo albumInfo = albumInfoVo.getData();
		Assert.notNull(albumInfo, "专辑信息不存在");
		if (trackInfoList.size()>=0){
//			生成一个map
			HashMap<String, Object> map = new HashMap<>();
			map.put("name", "本集数");
			map.put("price",albumInfo.getPrice());
			map.put("trackCount",0);
//			将map添加到list中
			list.add(map);
		}
		if (trackInfoList.size()>0 && trackInfoList.size()<=10){
			//生成一个map
			HashMap<String, Object> map = new HashMap<>();
			map.put("name", "后"+trackInfoList.size()+"集");
			map.put("price",albumInfo.getPrice().multiply(new BigDecimal(String.valueOf(trackInfoList.size()))));
			map.put("trackCount",trackInfoList.size());
//			将map添加到list中
			list.add(map);
		}
		// 19
		if(trackInfoList.size() > 10) {
			Map<String, Object> map = new HashMap<>();
			BigDecimal price = albumInfo.getPrice().multiply(new BigDecimal(10));
			map.put("name", "后10集");
			map.put("price", price);
			map.put("trackCount", 10);
			list.add(map);
		}
		// 后20集
		if(trackInfoList.size() > 10 && trackInfoList.size() <= 20) {
			Map<String, Object> map = new HashMap<>();
			int count = trackInfoList.size();
			BigDecimal price = albumInfo.getPrice().multiply(new BigDecimal(count));
			map.put("name", "后"+count+"集");
			map.put("price", price);
			map.put("trackCount", count);
			list.add(map);
		}
		if(trackInfoList.size() > 20) {
			Map<String, Object> map = new HashMap<>();
			BigDecimal price = albumInfo.getPrice().multiply(new BigDecimal(20));
			map.put("name", "后20集");
			map.put("price", price);
			map.put("trackCount", 20);
			list.add(map);
		}

		//后30集
		if(trackInfoList.size() > 20 && trackInfoList.size() <= 30) {
			Map<String, Object> map = new HashMap<>();
			int count = trackInfoList.size();
			BigDecimal price = albumInfo.getPrice().multiply(new BigDecimal(count));
			map.put("name", "后"+count+"集");
			map.put("price", price);
			map.put("trackCount", count);
			list.add(map);
		}
		if(trackInfoList.size() > 30) {
			Map<String, Object> map = new HashMap<>();
			BigDecimal price = albumInfo.getPrice().multiply(new BigDecimal(30));
			map.put("name", "后30集");
			map.put("price", price);
			map.put("trackCount", 30);
			list.add(map);
		}

		//后50集
		if(trackInfoList.size() > 30 && trackInfoList.size() <= 50) {
			Map<String, Object> map = new HashMap<>();
			int count = trackInfoList.size();
			BigDecimal price = albumInfo.getPrice().multiply(new BigDecimal(count));
			map.put("name", "后"+count+"集");
			map.put("price", price);
			map.put("trackCount", count);
			list.add(map);
		}
		// 最多购买50集;
		if(trackInfoList.size() > 50) {
			Map<String, Object> map = new HashMap<>();
			BigDecimal price = albumInfo.getPrice().multiply(new BigDecimal(50));
			map.put("name", "后50集");
			map.put("price", price);
			map.put("trackCount", 50);
			list.add(map);
		}
		return list;
	}

	@Override
	public List<TrackInfo> getTrackInfoList(Long trackId, Integer trackCount, Long userId) {
//		新建一个list 用于接收返回数据
		List<TrackInfo> trackInfoList = new ArrayList<>();
//		获取声音对应的声音信息id
		TrackInfo trackInfo = trackInfoMapper.selectOne(new LambdaQueryWrapper<TrackInfo>().eq(TrackInfo::getId, trackId));
//		如果trackCount的数量为0，就表示购买的本集
		if(trackCount==0){
			trackInfoList.add(trackInfo);
		}else {
			//		远程调用获取用户已经购买的声音列表
			Result<List<Long>> allPaidTracks = userInfoFeignClient.findAllPaidTracks(trackInfo.getAlbumId());
			Assert.notNull(allPaidTracks);
			List<Long> data = allPaidTracks.getData();
			if (ObjectUtils.isEmpty(data)){
				//		获取数据
				trackInfoList = trackInfoMapper.selectList(new LambdaQueryWrapper<TrackInfo>().eq(TrackInfo::getAlbumId, trackInfo.getAlbumId()).gt(TrackInfo::getOrderNum, trackInfo.getOrderNum()).last("limit 10"));
			}else {
				//		获取数据
				trackInfoList = trackInfoMapper.selectList(new LambdaQueryWrapper<TrackInfo>().eq(TrackInfo::getAlbumId, trackInfo.getAlbumId()).gt(TrackInfo::getOrderNum, trackInfo.getOrderNum()).notIn(TrackInfo::getId,data).last("limit 10"));
			}
		}
//		返回数据
		return trackInfoList;
	}
}